﻿using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Windows;
using System.Windows.Media;
using System.Collections.ObjectModel;
using System.Data;
using System.Windows.Media.Imaging;
using System.ComponentModel;
using System.Diagnostics;
using System.Windows.Controls;
using System.Globalization;
using produccion.modelo;
using produccion.AccesoDatos;
using produccion.clases;
using System.Windows.Input;
using System.Collections.Specialized;

namespace produccion.vistamodelo
{
    class VMmotivosReparacion:ViewModelBase
    {

        #region Campos

            private List<CLSMOTREPP> _lismotivos = new List<CLSMOTREPP>();
            private ProcesoProduccionRepositorio _repositorio = new ProcesoProduccionRepositorio();
            private MDOgeneral _mod = new MDOgeneral();

        #endregion

        #region Constructor

            public VMmotivosReparacion()
            {
                try
                {
                    consultarMotivos();
                    lismotivosrep.CollectionChanged += OnCollectionChanged;

                    if (MDOgeneral.conexion == null || MDOgeneral.conexion.State == ConnectionState.Closed)
                    {
                        MDOgeneral.conectar();
                    }
                    strTituloVentana = "Mantenimiento Motivos de Reparación - Usuario: " + MDOgeneral.usuario + " - [FRMmotivosReparacion]";
                }
                catch (Exception ex) { MessageBox.Show(ex.Message); }
            }

        #endregion

        #region propiedades

        private string _strTituloVentana;
        public string strTituloVentana
        {
            get { return _strTituloVentana; }
            set { _strTituloVentana = value; base.OnPropertyChanged("strTituloVentana"); }
        }

        private MDOgeneral.mensaje _msn = new MDOgeneral.mensaje();
        public MDOgeneral.mensaje msn 
        {
            get { return _msn; }
            set { _msn = value; base.OnPropertyChanged("msn"); }
        }

        private ObservableCollection<VMMotivosRep> _lismotivosrep = new ObservableCollection<VMMotivosRep>();
        public ObservableCollection<VMMotivosRep> lismotivosrep
        {
            get { return _lismotivosrep; }
            set { _lismotivosrep = value; base.OnPropertyChanged("lismotivosrep"); }
        }

        private VMMotivosRep _selmotivosrep;
        public VMMotivosRep selmotivosrep
        {
            get { return _selmotivosrep; }
            set { _selmotivosrep = value; base.OnPropertyChanged("selmotivosrep"); }
        }

        public List<CLSMOTREPP> lismotivos
        {
            get { return _lismotivos; }
            set { _lismotivos = value; base.OnPropertyChanged("lismotivos"); }
        }

        private Boolean _logValido;
        public Boolean logValido
        {
            get { return _logValido; }
            set { _logValido = value; base.OnPropertyChanged("logValido"); }
        }

        #endregion

        #region comandos

        RelayCommand _cmdSalir;
        public ICommand cmdSalir
        {
            get
            {
                if (_cmdSalir == null)
                {
                    _cmdSalir = new RelayCommand(Salir);
                }
                return _cmdSalir;
            }
        }

        RelayCommand _cmdGrabar;
        public ICommand cmdGrabar
        {
            get
            {
                if (_cmdGrabar == null)
                {
                    _cmdGrabar = new RelayCommand(parameter => grabarMotivosRep());
                }
                return _cmdGrabar;
            }
        }

        RelayCommand _cmdEliminar;
        public ICommand cmdEliminar
        {
            get
            {
                if (_cmdEliminar == null)
                {
                    _cmdEliminar = new RelayCommand(parameter => eliminarMotivosRep());
                }
                return _cmdEliminar;
            }
        }
  
        #endregion

        #region metodos

        public void consultarMotivos()
        {
            try
            {
                lismotivos = new CLSMOTREPP().listarReparaciones();
                List<VMMotivosRep> all = (from mot in lismotivos select new VMMotivosRep(mot)).ToList();
                foreach (VMMotivosRep mr in all)
                {
                    mr.validarMotivo += validaMotivo;
                    mr.PropertyChanged += OnPropertyChanged;
                }
                lismotivosrep = new ObservableCollection<VMMotivosRep>(all);
                lismotivosrep.CollectionChanged += OnCollectionChanged;
            }
            catch (Exception ex) { MessageBox.Show(ex.Message); }
        }

        void OnPropertyChanged(object sender, PropertyChangedEventArgs e)
        {
            try
            {
                logValido = ((from mr in lismotivosrep where mr.IsValid.Equals(false) select mr.IsValid).ToList().Count()) > 0 ? true : false;
            }
            catch (Exception ex) { MessageBox.Show(ex.Message); }
        }

        void OnCollectionChanged(object sender, NotifyCollectionChangedEventArgs e)
        {
            try
            {
                if (e.NewItems != null && e.NewItems.Count > 0)
                {
                    foreach (VMMotivosRep mr in e.NewItems)
                    {
                        mr.validarMotivo += validaMotivo;
                        mr.PropertyChanged += OnPropertyChanged;
                    }
                }
            }
            catch (Exception ex) { MessageBox.Show(ex.Message); }
        }

        public string validaMotivo(string motrep)
        {
            try
            {
                int i = (from mr in lismotivosrep where mr.codmot_mrp.Equals(motrep.Trim()) select mr).ToList().Count();
                if (i > 1)
                {
                    return "Motivo de reparación ya existe.";
                }
            }
            catch (Exception ex) { MessageBox.Show(ex.Message); }
            return null;
        }

        private void grabarMotivosRep()
        {
            try
            {
                Mouse.OverrideCursor = Cursors.Wait;
                List<CLSMOTREPP> lstAgregar = (from mr in lismotivosrep where mr.agregar.Equals(true) select mr.getMotivosRep()).ToList();
                List<CLSMOTREPP> lstActualizar = (from mr in lismotivosrep where mr.actualizar.Equals(true) select mr.getMotivosRep()).ToList();
                List<CLSMOTREPP> lstEliminar = (from mr in lismotivosrep where mr.eliminar.Equals(true) select mr.getMotivosRep()).ToList();

                if (_repositorio.guardarMotivosRep(lstActualizar, lstEliminar, lstAgregar))
                {
                    msn.texto = "La información se guardo con exito.";
                    msn.tipo = true;
                    consultarMotivos();
                }
                else
                {
                    msn.texto = "La información de motivos de reparación no se pudo grabar.";
                    msn.tipo = false;
                }
                Mouse.OverrideCursor = Cursors.Arrow;
            }
            catch (Exception ex) { MessageBox.Show(ex.Message); }
        }

        public void eliminarMotivosRep()
        {
            try
            {
                if (selmotivosrep.agregar)
                    lismotivosrep.Remove(selmotivosrep);
                else
                    selmotivosrep.eliminar = !selmotivosrep.eliminar;
            }
            catch (Exception ex) { MessageBox.Show(ex.Message); }
        }

        public void Salir(object frm)
        {
            try
            {
                ((Window)frm).Close();
            }
            catch (Exception ex) { MessageBox.Show(ex.Message); }
        }


        #endregion

    }

    #region Vistas-Model

    public class VMMotivosRep : ViewModelBase, IDataErrorInfo
    {

        #region Campos

        private CLSMOTREPP _motivosRep = new CLSMOTREPP();
        
        #endregion

        #region Constructor

        public VMMotivosRep(CLSMOTREPP motivosRep)
        {
            _motivosRep = motivosRep;
        }

        public VMMotivosRep()
        {
            agregar = true;
            base.OnPropertyChanged("codmot_mrp");
        }

        #endregion

        #region Metodos
        public delegate string validarMotivosRep(string codmot_mrp);

        public CLSMOTREPP getMotivosRep()
        {
            return _motivosRep;
        }

        #endregion

        #region Propiedades

        public validarMotivosRep validarMotivo;

        public string codmot_mrp
        {
            get { return _motivosRep.CODMOT_MRP; }
            set 
            {
                if (agregar == true)
                {
                    _motivosRep.CODMOT_MRP = value;
                    base.OnPropertyChanged("codmot_mrp");
                }
            }
        }

        public string nommot_mrp
        {
            get { return _motivosRep.NOMMOT_MRP; }
            set 
            {
                if (_motivosRep.NOMMOT_MRP != value && agregar == false)
                    actualizar = true;
                _motivosRep.NOMMOT_MRP = value;
                base.OnPropertyChanged("nommot_mrp");
            }
        }

        public Int32 premed_mrp
        {
            get { return _motivosRep.PREMED_MRP; }
            set 
            {
                if (_motivosRep.PREMED_MRP != value && agregar == false)
                    actualizar = true; 
                _motivosRep.PREMED_MRP = value;
                base.OnPropertyChanged("premed_mrp"); 
            }
        }

        public Int32 prebog_mrp
        {
            get { return _motivosRep.PREBOG_MRP; }
            set 
            {
                if (_motivosRep.PREBOG_MRP != value && agregar == false)
                    actualizar = true; 
                _motivosRep.PREBOG_MRP = value;
                base.OnPropertyChanged("prebog_mrp"); 
            }
        }

        public Int32 costo_mrp
        {
            get { return _motivosRep.COSTO_MRP; }
            set 
            {
                if (_motivosRep.COSTO_MRP != value && agregar == false)
                    actualizar = true; 
                _motivosRep.COSTO_MRP = value;
                base.OnPropertyChanged("costo_mrp"); }
        }

        private bool _actualizar = false;
        public bool actualizar
        {
            get { return _actualizar; }
            set { _actualizar = value; base.OnPropertyChanged("actualizar"); }
        }

        private bool _eliminar = false;
        public bool eliminar
        {
            get { return _eliminar; }
            set { _eliminar = value; base.OnPropertyChanged("eliminar"); }
        }

        private bool _agregar = false;
        public bool agregar
        {
            get { return _agregar; }
            set { _agregar = value; base.OnPropertyChanged("agregar"); }
        }

        #endregion

        #region IDataErrorInfo Members

        string IDataErrorInfo.Error { get { return null; } }

        string IDataErrorInfo.this[string propertyName]
        {
            get { return this.GetValidationError(propertyName); }
        }

        #endregion

        #region Validation

        /// <summary>
        /// Returns true if this object has no validation errors.
        /// </summary>
        /// 

        public bool IsValid
        {
            get
            {
                foreach (string property in ValidatedProperties)
                    if (GetValidationError(property) != null)
                        return false;
                return true;
            }
        }

        static readonly string[] ValidatedProperties = 
        { 
            "codmot_mrp",
            "nommot_mrp",
            "premed_mrp",
            "prebog_mrp",
            "costo_mrp"
        };

        string GetValidationError(string propertyName)
        {
            if (Array.IndexOf(ValidatedProperties, propertyName) < 0)
                return null;

            string error = null;

            switch (propertyName)
            {
                case "codmot_mrp":
                    error = Validatecodigo();
                    break;
                case "nommot_mrp":
                    error = Validatenombre();
                    break;
                case "premed_mrp":
                    error = Validatemedellin();
                    break;
                case "prebog_mrp":
                    error = Validatebogota();
                    break;
                case "costo_mrp":
                    error = Validatecosto();
                    break;
                default:
                    Debug.Fail("Unexpected property being validated on Customer: " + propertyName);
                    break;
            }
            return error;
        }

        string Validatecodigo()
        {
            try
            {
                if (codmot_mrp == null) { return "Debe ingresar el código del concepto de facturación."; }
                else
                {
                    if (codmot_mrp.Length > 3) { return "El código del motivo de reparacion no puede tener mas de 3 caracteres"; }
                    string error = null;
                    error = validarMotivo(codmot_mrp);
                    if (!String.IsNullOrEmpty(error))
                    {
                        return error;
                    }
                }
                return null;
            }
            catch (Exception ex) { MessageBox.Show(ex.Message); }
            return null;
        }

        string Validatenombre()
        {
            try
            {
                if (nommot_mrp == null) { return "Debe ingresar el nombre del concepto de facturación"; }
                if (nommot_mrp.Length > 20) { return "El nombre del motivo no puede tener mas de 20 caracteres"; }

                return null;
            }
            catch (Exception ex) { MessageBox.Show(ex.Message); }
            return null;
        }

        string Validatemedellin()
        {
            try
            {
                if (premed_mrp < 0) { return "Valor de Medellin no valido"; }
                return null;
            }
            catch (Exception ex) { MessageBox.Show(ex.Message); }
            return null;
        }

        string Validatebogota()
        {
            try
            {
                if (prebog_mrp < 0) { return "Valor de Bogota no valido"; }
                return null;
            }
            catch (Exception ex) { MessageBox.Show(ex.Message); }
            return null;
        }

        string Validatecosto()
        {
            try
            {
                if (costo_mrp < 0) { return "Costo no valido"; }
                return null;
            }
            catch (Exception ex) { MessageBox.Show(ex.Message); }
            return null;
        }
        #endregion

    }

     #endregion

}

